home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / etc / bash_completion.d / shadow < prev    next >
Encoding:
Text File  |  2010-11-16  |  9.7 KB  |  478 lines
  1. # bash completion for shadow utils
  2.  
  3. have useradd &&
  4. _useradd()
  5. {
  6.     local cur prev split=false
  7.  
  8.     COMPREPLY=()
  9.     _get_comp_words_by_ref cur prev
  10.  
  11.     _split_longopt && split=true
  12.  
  13.     # TODO: if -o/--non-unique is given, could complete on existing uids
  14.     #       with -u/--uid
  15.  
  16.     case $prev in
  17.         -c|--comment|-h|--help|-e|--expiredate|-f|--inactive|-k|--key|-p|--password|-u|--uid|-Z|--selinux-user)
  18.             return 0
  19.             ;;
  20.         -b|--base-dir|-d|--home|-k|--skel)
  21.             _filedir -d
  22.             return 0
  23.             ;;
  24.         -g|--gid)
  25.             _gids
  26.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $( compgen -g )' \
  27.                 -- "$cur" ) )
  28.             return 0
  29.             ;;
  30.         -G|--groups)
  31.             COMPREPLY=( $( compgen -g -- "$cur" ) )
  32.             return 0
  33.             ;;
  34.         -s|--shell)
  35.             _shells
  36.             return 0
  37.             ;;
  38.     esac
  39.  
  40.     $split && return 0
  41.  
  42.     if [[ "$cur" == -* ]]; then
  43.         COMPREPLY=( $( compgen -W '--base-dir --comment --home-dir --defaults \
  44.             --expiredate --inactive --gid --groups --help --skel --key \
  45.             --no-log-init --create-home --no-create-home --no-user-group \
  46.             --non-unique --password --system --shell --uid --user-group \
  47.             --selinux-user' -- "$cur" ) )
  48.         return 0
  49.     fi
  50. } &&
  51. complete -F _useradd useradd
  52.  
  53. have usermod &&
  54. _usermod()
  55. {
  56.     local cur prev split=false
  57.  
  58.     COMPREPLY=()
  59.     _get_comp_words_by_ref cur prev
  60.  
  61.     _split_longopt && split=true
  62.  
  63.     # TODO: if -o/--non-unique is given, could complete on existing uids
  64.     #       with -u/--uid
  65.  
  66.     case $prev in
  67.         -c|--comment|-d|--home|-e|--expiredate|-f|--inactive|-h|--help|-l|--login|-p|--password|-u|--uid|-Z|--selinux-user)
  68.             return 0
  69.             ;;
  70.         -g|--gid)
  71.             _gids
  72.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $( compgen -g )' \
  73.                 -- "$cur" ) )
  74.             return 0
  75.             ;;
  76.         -G|--groups)
  77.             COMPREPLY=( $( compgen -g -- "$cur" ) )
  78.             return 0
  79.             ;;
  80.         -s|--shell)
  81.             _shells
  82.             return 0
  83.             ;;
  84.     esac
  85.  
  86.     $split && return 0
  87.  
  88.     if [[ "$cur" == -* ]]; then
  89.         # TODO: -U/--unlock, -p/--password, -L/--lock mutually exclusive
  90.         COMPREPLY=( $( compgen -W '--append --comment --home --expiredate \
  91.             --inactive --gid --groups --help --login --lock --move-home \
  92.             --non-unique --password --shell --uid --unlock --selinux-user' \
  93.             -- "$cur" ) )
  94.         return 0
  95.     fi
  96.  
  97.     COMPREPLY=( $( compgen -u -- "$cur" ) )
  98. } &&
  99. complete -F _usermod usermod
  100.  
  101. have userdel &&
  102. _userdel()
  103. {
  104.     local cur
  105.  
  106.     COMPREPLY=()
  107.     _get_comp_words_by_ref cur
  108.  
  109.     if [[ "$cur" == -* ]]; then
  110.         COMPREPLY=( $( compgen -W '--force --help --remove' -- "$cur" ) )
  111.         return 0
  112.     fi
  113.  
  114.     COMPREPLY=( $( compgen -u -- "$cur" ) )
  115. } &&
  116. complete -F _userdel userdel
  117.  
  118. have chage &&
  119. _chage()
  120. {
  121.     local cur prev split=false
  122.  
  123.     COMPREPLY=()
  124.     _get_comp_words_by_ref cur prev
  125.  
  126.     _split_longopt && split=true
  127.  
  128.     case $prev in
  129.         -d|--lastday|-E|--expiredate|-h|--help|-I|--inactive|-m|--mindays|-M|--maxdays|-W|--warndays)
  130.             return 0
  131.             ;;
  132.     esac
  133.  
  134.     $split && return 0
  135.  
  136.     if [[ "$cur" == -* ]]; then
  137.         COMPREPLY=( $( compgen -W '--lastday --expiredate --help --inactive \
  138.             --list --mindays --maxdays --warndays' -- "$cur" ) )
  139.         return 0
  140.     fi
  141.  
  142.     COMPREPLY=( $( compgen -u -- "$cur" ) )
  143. } &&
  144. complete -F _chage chage
  145.  
  146. have passwd &&
  147. _passwd()
  148. {
  149.     local cur prev
  150.  
  151.     COMPREPLY=()
  152.     _get_comp_words_by_ref cur prev
  153.  
  154.     case $prev in
  155.         -n|-x|-w|-i|-\?|--help|--usage)
  156.             return 0
  157.             ;;
  158.     esac
  159.  
  160.     if [[ "$cur" == -* ]]; then
  161.         COMPREPLY=( $( compgen -W '-k -l --stdin -u -d -n -x -w -i -S \
  162.             -? --help --usage' -- "$cur" ) )
  163.         return 0
  164.     fi
  165.  
  166.     COMPREPLY=( $( compgen -u -- "$cur" ) )
  167. } &&
  168. complete -F _passwd passwd
  169.  
  170. have chpasswd &&
  171. _chpasswd()
  172. {
  173.     local cur prev split=false
  174.  
  175.     COMPREPLY=()
  176.     _get_comp_words_by_ref cur prev
  177.  
  178.     _split_longopt && split=true
  179.  
  180.     case $prev in
  181.         -c|--crypt)
  182.             COMPREPLY=( $( compgen -W 'DES MD5 NONE SHA256 SHA512' \
  183.                 -- "$cur" ) )
  184.             return 0
  185.             ;;
  186.         -s|--sha-rounds)
  187.             return 0
  188.             ;;
  189.     esac
  190.  
  191.     $split && return 0
  192.  
  193.     if [[ "$cur" == -* ]]; then
  194.         COMPREPLY=( $( compgen -W '--crypt-method --encrypted \
  195.             --help --md5 --sha-rounds' -- "$cur" ) )
  196.         return 0
  197.     fi
  198. } &&
  199. complete -F _chpasswd chpasswd
  200.  
  201. have newusers &&
  202. _newusers()
  203. {
  204.     local cur prev split=false
  205.  
  206.     COMPREPLY=()
  207.     _get_comp_words_by_ref cur prev
  208.  
  209.     _split_longopt && split=true
  210.  
  211.     case $prev in
  212.         -c|--crypt)
  213.             COMPREPLY=( $( compgen -W 'DES MD5 NONE SHA256 SHA512' \
  214.                 -- "$cur" ) )
  215.             return 0
  216.             ;;
  217.         -s|--sha-rounds)
  218.             return 0
  219.             ;;
  220.     esac
  221.  
  222.     $split && return 0
  223.  
  224.     if [[ "$cur" == -* ]]; then
  225.         COMPREPLY=( $( compgen -W '--crypt-method --help --system \
  226.             --sha-rounds' -- "$cur" ) )
  227.         return 0
  228.     fi
  229.  
  230.     _filedir
  231. } &&
  232. complete -F _newusers -o filenames newusers
  233.  
  234. have pwck &&
  235. _pwck()
  236. {
  237.     local cur
  238.  
  239.     COMPREPLY=()
  240.     _get_comp_words_by_ref cur
  241.  
  242.     if [[ "$cur" == -* ]]; then
  243.         COMPREPLY=( $( compgen -W '-q -r -s' -- "$cur" ) )
  244.         return 0
  245.     fi
  246.  
  247.     _filedir
  248. } &&
  249. complete -F _pwck -o filenames pwck
  250.  
  251. have groupadd &&
  252. _groupadd()
  253. {
  254.     local cur prev split=false
  255.  
  256.     COMPREPLY=()
  257.     _get_comp_words_by_ref cur prev
  258.  
  259.     _split_longopt && split=true
  260.  
  261.     # TODO: if -o/--non-unique is given, could complete on existing gids
  262.     #       with -g/--gid
  263.  
  264.     case $prev in
  265.         -g|--gid|-K|--key|-p|--password)
  266.             return 0
  267.             ;;
  268.     esac
  269.  
  270.     $split && return 0
  271.  
  272.     if [[ "$cur" == -* ]]; then
  273.         COMPREPLY=( $( compgen -W '--force --gid --help \
  274.             --key --non-unique --password --system' -- "$cur" ) )
  275.         return 0
  276.     fi
  277. } &&
  278. complete -F _groupadd groupadd
  279.  
  280. have groupmod &&
  281. _groupmod()
  282. {
  283.     local cur prev split=false
  284.  
  285.     COMPREPLY=()
  286.     _get_comp_words_by_ref cur prev
  287.  
  288.     _split_longopt && split=true
  289.  
  290.     # TODO: if -o/--non-unique is given, could complete on existing gids
  291.     #       with -g/--gid
  292.  
  293.     case $prev in
  294.         -g|--gid|-h|--help|-n|--new-name|-p|--password)
  295.             return 0
  296.             ;;
  297.     esac
  298.  
  299.     $split && return 0
  300.  
  301.     if [[ "$cur" == -* ]]; then
  302.         COMPREPLY=( $( compgen -W '--gid --help --new-name \
  303.             --non-unique --password' -- "$cur" ) )
  304.         return 0
  305.     fi
  306.  
  307.     COMPREPLY=( $( compgen -g -- "$cur" ) )
  308. } &&
  309. complete -F _groupmod groupmod
  310.  
  311. complete -g groupdel
  312.  
  313. have newgrp &&
  314. _newgrp()
  315. {
  316.     COMPREPLY=()
  317.     if [[ "`_get_cword`" == "-" ]]; then
  318.         COMPREPLY=( - )
  319.     fi
  320. } &&
  321. complete -g -F _newgrp newgrp
  322.  
  323. have gpasswd &&
  324. _gpasswd()
  325. {
  326.     local cur prev
  327.  
  328.     COMPREPLY=()
  329.     _get_comp_words_by_ref cur prev
  330.  
  331.     case $prev in
  332.         -a|-d|-A|-M)
  333.             COMPREPLY=( $( compgen -u -- "$cur" ) )
  334.             return 0
  335.             ;;
  336.     esac
  337.  
  338.     if [[ "$cur" == -* ]]; then
  339.         COMPREPLY=( $( compgen -W '-a -d -r -R -A -M' -- "$cur" ) )
  340.         return 0
  341.     fi
  342.  
  343.     COMPREPLY=( $( compgen -g -- "$cur" ) )
  344. } &&
  345. complete -F _gpasswd gpasswd
  346.  
  347. have groupmems &&
  348. _groupmems()
  349. {
  350.     local cur prev
  351.  
  352.     COMPREPLY=()
  353.     _get_comp_words_by_ref cur prev
  354.  
  355.     case $prev in
  356.         -a|-d)
  357.             COMPREPLY=( $( compgen -u -- "$cur" ) )
  358.             return 0
  359.             ;;
  360.         -g)
  361.             COMPREPLY=( $( compgen -g -- "$cur" ) )
  362.             return 0
  363.             ;;
  364.     esac
  365.  
  366.     if [[ "$cur" == -* ]]; then
  367.         COMPREPLY=( $( compgen -W '-a -d -p -g -l' -- "$cur" ) )
  368.         return 0
  369.     fi
  370. } &&
  371. complete -F _groupmems groupmems
  372.  
  373. have grpck &&
  374. _grpck()
  375. {
  376.     local cur
  377.  
  378.     COMPREPLY=()
  379.     _get_comp_words_by_ref cur
  380.  
  381.     if [[ "$cur" == -* ]]; then
  382.         COMPREPLY=( $( compgen -W '-r -s' -- "$cur" ) )
  383.         return 0
  384.     fi
  385.  
  386.     _filedir
  387. } &&
  388. complete -F _grpck -o filenames grpck
  389.  
  390. have vipw || have vigr &&
  391. _vipw()
  392. {
  393.     local cur prev
  394.  
  395.     COMPREPLY=()
  396.     _get_comp_words_by_ref cur prev
  397.  
  398.     case $prev in
  399.         -h|--help)
  400.             return 0
  401.             ;;
  402.     esac
  403.  
  404.     if [[ "$cur" == -* ]]; then
  405.         COMPREPLY=( $( compgen -W '--group --help --passwd \
  406.             --quiet --shadow' -- "$cur" ) )
  407.         return 0
  408.     fi
  409. } &&
  410. complete -F _vipw vipw vigr
  411.  
  412. have faillog &&
  413. _faillog()
  414. {
  415.     local cur prev split=false
  416.  
  417.     COMPREPLY=()
  418.     _get_comp_words_by_ref cur prev
  419.  
  420.     _split_longopt && split=true
  421.  
  422.     case $prev in
  423.         -h|--help|-l|--lock-time|-m|--maximum|-t|--time)
  424.             return 0
  425.             ;;
  426.         -u|--user)
  427.             COMPREPLY=( $( compgen -u -- "$cur" ) )
  428.             return 0
  429.             ;;
  430.     esac
  431.  
  432.     $split && return 0
  433.  
  434.     if [[ "$cur" == -* ]]; then
  435.         COMPREPLY=( $( compgen -W '--all --help --lock-time \
  436.             --maximum --reset --time --user' -- "$cur" ) )
  437.         return 0
  438.     fi
  439. } &&
  440. complete -F _faillog faillog
  441.  
  442. have lastlog &&
  443. _lastlog()
  444. {
  445.     local cur prev split=false
  446.  
  447.     COMPREPLY=()
  448.     _get_comp_words_by_ref cur prev
  449.  
  450.     _split_longopt && split=true
  451.  
  452.     case $prev in
  453.         -b|--before|-h|--help|-t|--time)
  454.             return 0
  455.             ;;
  456.         -u|--user)
  457.             COMPREPLY=( $( compgen -u -- "$cur" ) )
  458.             return 0
  459.             ;;
  460.     esac
  461.  
  462.     $split && return 0
  463.  
  464.     if [[ "$cur" == -* ]]; then
  465.         COMPREPLY=( $( compgen -W '--before --help --time --user' -- "$cur" ) )
  466.         return 0
  467.     fi
  468. } &&
  469. complete -F _lastlog lastlog
  470.  
  471. # Local variables:
  472. # mode: shell-script
  473. # sh-basic-offset: 4
  474. # sh-indent-comment: t
  475. # indent-tabs-mode: nil
  476. # End:
  477. # ex: ts=4 sw=4 et filetype=sh
  478.